Algoritmo KNN - Modelo Binário

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import sklearn
from sklearn.model_selection import train_test_split
from sklearn.utils import resample
from sklearn.ensemble import RandomForestClassifier

df = pd.read_csv('/content/winequality.csv')
df.head()

	Unnamed: 0	fixed acidity	volatile acidity	citric acid	residual sugar	chlorides	free sulfur dioxide	total sulfur dioxide	density	pH	sulphates	alcohol	quality	wine_is_red
0	0	5.9	0.61	0.08	2.1	0.071	16.0	24.0	0.99376	3.56	0.77	11.1	6	1
1	1	8.2	1.00	0.09	2.3	0.065	7.0	37.0	0.99685	3.32	0.55	9.0	6	1
2	2	6.4	0.24	0.49	5.8	0.053	25.0	120.0	0.99420	3.01	0.98	10.5	6	0
3	3	6.6	0.23	0.26	1.3	0.045	16.0	128.0	0.99340	3.36	0.60	10.0	6	0
4	4	7.2	0.24	0.29	3.0	0.036	17.0	117.0	0.99411	3.36	0.68	10.1	6	0

# NÃO RODAR NÃO RODAR NÃO RODAR NÃO RODAR NÃO RODAR NÃO RODAR NÃO RODAR NÃO RODAR NÃO RODAR 
plt.close(); # NÃO RODAR
sns.set_style('whitegrid');
sns.pairplot(df, hue='wine_is_red', height=3);
plt.show()   #não recomendo rodar de novo, muito pesado kkkkkkkkkkkkk

1 - Tratando o banco:

print(df.shape,np.unique(df.isna().to_numpy(),return_counts=True)) #sem nenhum NA

(6497, 14) (array([False]), array([90958]))

df.isna().sum()

Unnamed: 0              0
fixed acidity           0
volatile acidity        0
citric acid             0
residual sugar          0
chlorides               0
free sulfur dioxide     0
total sulfur dioxide    0
density                 0
pH                      0
sulphates               0
alcohol                 0
quality                 0
wine_is_red             0
dtype: int64

# normalizando:

for i in df.columns:
  df[i] = (df[i] - df[i].min()) / (df[i].max() - df[i].min())

df.head()

	Unnamed: 0	fixed acidity	volatile acidity	citric acid	residual sugar	chlorides	free sulfur dioxide	total sulfur dioxide	density	pH	sulphates	alcohol	quality	wine_is_red
0	0.000000	0.173554	0.353333	0.048193	0.023006	0.102990	0.052083	0.041475	0.128205	0.651163	0.308989	0.449275	0.5	1.0
1	0.000154	0.363636	0.613333	0.054217	0.026074	0.093023	0.020833	0.071429	0.187777	0.465116	0.185393	0.144928	0.5	1.0
2	0.000308	0.214876	0.106667	0.295181	0.079755	0.073090	0.083333	0.262673	0.136688	0.224806	0.426966	0.362319	0.5	0.0
3	0.000462	0.231405	0.100000	0.156627	0.010736	0.059801	0.052083	0.281106	0.121265	0.496124	0.213483	0.289855	0.5	0.0
4	0.000616	0.280992	0.106667	0.174699	0.036810	0.044850	0.055556	0.255760	0.134953	0.496124	0.258427	0.304348	0.5	0.0

Agora, veremos como está distribuído nosso dataframe sobre as respostas da variável "wine_is_red"

df.wine_is_red.value_counts()

0.0    4898
1.0    1599
Name: wine_is_red, dtype: int64

# igualizando o número de observações de cada classe

df_red = df[df.wine_is_red==1]
df_white = df[df.wine_is_red==0]

df_white = resample(df_white, replace = False, n_samples = 1599)

df = pd.concat([df_white,df_red])

df.wine_is_red.value_counts()

1.0    1599
0.0    1599
Name: wine_is_red, dtype: int64

# Separando nosso df em treino e teste:

x = df.drop(columns='wine_is_red')
y = df.wine_is_red

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)

x_train = np.array(x_train) 
x_test = np.array(x_test) 
y_train = np.array(y_train) 
y_test = np.array(y_test)

2 - Implementação

# distancia = ((a1 - a2)^2 + (b1-b2)^2 + ... + (m1 - m2)^2 )^0.5, sendo a1,...,m1 = treino e a2,...,m2 = teste, m é a 13ª letra do alfabeto, 
# usada porque o x_train possui 13 variáveis (ou dimensões)

d = [np.sqrt(np.sum(np.square((i - x_train)), axis=1)) for i in x_test]

kk = len(d)
kk

640

resposta = np.array([]) #array das classificações com maior frequência
k = 5 #k vizinhos mais próximos do ponto

for i in range(kk):
  indices = d[i].argsort()[:k] #índice de cada ponto mais próximo 
  neighbors = [] #k vizinhos mais próximos do ponto são guardados aqui
  for j in range(k):
    neighbors.append(y_train[indices[j]]) #classificacao dos pontos
  resposta = np.append(resposta,max(set(neighbors), key=neighbors.count)) #classificação mais frequente

c = 0

for i in range(kk):
  if resposta[i] == y_test[i]:
    c += 1

print(f'Eficiência do algoritmo: {round((c/len(d))*100,2)}%')

Eficiência do algoritmo: 97.34%

Algoritmo KNN - Modelo Multiclasse

df = pd.read_csv('/content/winequality.csv')
df.head()

	Unnamed: 0	fixed acidity	volatile acidity	citric acid	residual sugar	chlorides	free sulfur dioxide	total sulfur dioxide	density	pH	sulphates	alcohol	quality	wine_is_red
0	0	5.9	0.61	0.08	2.1	0.071	16.0	24.0	0.99376	3.56	0.77	11.1	6	1
1	1	8.2	1.00	0.09	2.3	0.065	7.0	37.0	0.99685	3.32	0.55	9.0	6	1
2	2	6.4	0.24	0.49	5.8	0.053	25.0	120.0	0.99420	3.01	0.98	10.5	6	0
3	3	6.6	0.23	0.26	1.3	0.045	16.0	128.0	0.99340	3.36	0.60	10.0	6	0
4	4	7.2	0.24	0.29	3.0	0.036	17.0	117.0	0.99411	3.36	0.68	10.1	6	0

df.quality.value_counts() # tirar 0 e 1: testar tirando e deixando

6    2836
5    2138
7    1079
4     216
8     193
3      30
9       5
Name: quality, dtype: int64

# igualizando o número de observações de cada classe

df_9 = df[df.quality==9]
df_3 = df[df.quality==3]
df_8 = df[df.quality==8]
df_4 = df[df.quality==4]
df_7 = df[df.quality==7]
df_5 = df[df.quality==5]
df_6 = df[df.quality==6]

# FORMA RETIRANDO AS CATEGORIAS 9 E 3, COM POUCAS OBSERVACOES

df_8 = resample(df_8, replace = False, n_samples = 193)
df_4 = resample(df_4, replace = False, n_samples = 193)
df_7 = resample(df_7, replace = False, n_samples = 193)
df_5 = resample(df_5, replace = False, n_samples = 193)
df_6 = resample(df_6, replace = False, n_samples = 193)

df1 = pd.concat([df_8,df_4,df_7,df_5,df_6])

df1.quality.value_counts()

8    193
7    193
6    193
5    193
4    193
Name: quality, dtype: int64

df_8 = resample(df_8, replace = False, n_samples = 100)
df_4 = resample(df_4, replace = False, n_samples = 100)
df_7 = resample(df_7, replace = False, n_samples = 100)
df_5 = resample(df_5, replace = False, n_samples = 100)
df_6 = resample(df_6, replace = False, n_samples = 100)

df = pd.concat([df_9,df_3,df_8,df_4,df_7,df_5,df_6])

df.quality.value_counts()

8    100
7    100
6    100
5    100
4    100
3     30
9      5
Name: quality, dtype: int64

# normalizando:

for i in df.columns:
  df[i] = (df[i] - df[i].min()) / (df[i].max() - df[i].min())

for i in df1.columns:
  df1[i] = (df1[i] - df1[i].min()) / (df1[i].max() - df1[i].min())

df1.head()

	Unnamed: 0	fixed acidity	volatile acidity	citric acid	residual sugar	chlorides	free sulfur dioxide	total sulfur dioxide	density	pH	sulphates	alcohol	quality	wine_is_red
1949	0.300077	0.336735	0.245614	0.31	0.074074	0.073579	0.088561	0.083019	0.507014	0.422414	0.291429	0.517857	1.0	1.0
5692	0.877255	0.346939	0.175439	0.34	0.111111	0.053512	0.228782	0.381132	0.261857	0.534483	0.160000	0.785714	1.0	0.0
1297	0.199537	0.316327	0.017544	0.29	0.513228	0.045151	0.280443	0.343396	0.568470	0.387931	0.074286	0.250000	1.0	0.0
2585	0.398150	0.193878	0.188596	0.27	0.050265	0.023411	0.088561	0.237736	0.187709	0.543103	0.085714	0.625000	1.0	0.0
3381	0.520894	0.214286	0.070175	0.31	0.042328	0.040134	0.081181	0.256604	0.248497	0.517241	0.188571	0.482143	1.0	0.0

# Separando nosso df em treino e teste:

x = df.drop(columns='quality')
y = df.quality

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)

x_train = np.array(x_train) 
x_test = np.array(x_test) 
y_train = np.array(y_train) 
y_test = np.array(y_test)

# BANCO SEM 9 E 3

x1 = df1.drop(columns='quality')
y1 = df1.quality

x1_train, x1_test, y1_train, y1_test = train_test_split(x1, y1, test_size=0.2)

x1_train = np.array(x1_train) 
x1_test = np.array(x1_test) 
y1_train = np.array(y1_train) 
y1_test = np.array(y1_test)

# distancia = ((a1 - a2)^2 + (b1-b2)^2 + ... + (m1 - m2)^2 )^0.5, sendo a1,...,m1 = treino e a2,...,m2 = teste, m é a 13ª letra do alfabeto, 
# usada porque o x_train possui 13 variáveis (ou dimensões)

d = [np.sqrt(np.sum(np.square((i - x_train)), axis=1)) for i in x_test]

kk = len(d)

# SEM 9 E 3

d1 = [np.sqrt(np.sum(np.square((i - x1_train)), axis=1)) for i in x1_test]

kk1 = len(d1)

print(kk,kk1)

107 193

resposta = np.array([]) #array das classificações com maior frequência
k = 7 #k vizinhos mais próximos do ponto

for i in range(kk):
  indices = d[i].argsort()[:k] #índice de cada ponto mais próximo 
  neighbors = [] #k vizinhos mais próximos do ponto são guardados aqui
  for j in range(k):
    neighbors.append(y_train[indices[j]]) #classificacao dos pontos
  resposta = np.append(resposta,max(set(neighbors), key=neighbors.count)) #classificação mais frequente

resposta1 = np.array([]) #array das classificações com maior frequência
k1 = 7 #k vizinhos mais próximos do ponto

for i in range(kk1):
  indices1 = d1[i].argsort()[:k] #índice de cada ponto mais próximo 
  neighbors1 = [] #k vizinhos mais próximos do ponto são guardados aqui
  for j in range(k1):
    neighbors1.append(y1_train[indices1[j]]) #classificacao dos pontos
  resposta1 = np.append(resposta1,max(set(neighbors1), key=neighbors1.count)) #classificação mais frequente

c = 0
c1 = 0

for i in range(kk):
  if resposta[i] == y_test[i]:
    c += 1

for i in range(kk1):
  if resposta1[i] == y1_test[i]:
    c1 += 1

print(f'Eficiência do algoritmo sem a retirada: {round((c/len(d))*100,2)}% \n Eficiência do algoritmo com a retirada: {round((c1/len(d1))*100,2)}%')

Eficiência do algoritmo sem a retirada: 27.1% 
 Eficiência do algoritmo com a retirada: 45.6%

Feature Importance - Aplicar ao algoritmo Random Forest e determinar quais features do dataset são mais importantes para o problema;

Lembrete:

• Aplicar a normalização nos dados e verificar os efeitos nos modelos;
• Aplicar as técnicas de undersampling e oversampling nos dados. Verificar e explicar os efeitos;

Aplicar um dos métodos de Ensemble Learning e comparar os resultados.

Lembrete:

• Aplicar a normalização nos dados e verificar os efeitos nos modelos;
• Aplicar as técnicas de undersampling e oversampling nos dados. Verificar e explicar os efeitos;